Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/app/e2e/session/session-renderer-diagnostics.spec.ts`:
- Around line 39-44: Replace the outright replacement of
win.api.emitRendererDiagnostic with a wrapper that delegates to the existing
implementation: capture the original function (e.g., const originalEmit =
win.api?.emitRendererDiagnostic), then assign a new async emitRendererDiagnostic
that calls await originalEmit?.call(win.api, event) (if present) and still
pushes a deep-cloned event into win.__pawwork_renderer_diagnostics; keep other
win.api properties untouched and preserve async/return behavior so a broken
preload/IPC handler is still exercised by the test while recording the event.

In `@packages/app/src/components/prompt-input/submit.ts`:
- Around line 523-540: The diagnostics are reading mutable state after calling
removeCommentItems() and clearInput(), and the fire-and-forget
emitRendererDiagnostic(...) silently drops rejections; capture metrics into
local variables (e.g., const commentCount = input.commentCount(), promptLen =
input.promptLength(currentPrompt), imageCount = images.length) before calling
removeCommentItems() / clearInput(), then call emitRendererDiagnostic with those
captured values and handle async failures (await the promise and wrap in
try/catch or attach a .catch to log/report errors) so failures aren’t ignored;
update references to messageID, session.id, model.providerID/model.modelID as
before when building the payload.

In `@packages/app/src/context/renderer-diagnostics.ts`:
- Around line 169-185: The emitted fps should be the real frames-per-second over
the sample period, not raw frameCount; in flush() replace fps: frameCount with a
computed value framesPerSecond = Math.round(frameCount / (sampleDurationMs /
1000)), where sampleDurationMs is the elapsed milliseconds since the previous
flush (track a lastFlushTimestamp set when diagnostics start and update it at
the end of flush(), initialize it on start); use framesPerSecond in the event
payload (and keep rounding/undefined handling consistent with other metrics).

In `@packages/app/src/pages/session/message-timeline.tsx`:
- Around line 739-755: The scroll diagnostic currently calls
emitRendererDiagnostic on every scroll event (hot path), causing excessive IPC
and jank; change it to throttle via requestAnimationFrame (or an RAF-backed
boolean guard) so emitRendererDiagnostic(...) runs at most once per animation
frame instead of per event, and clamp the computed distance_from_bottom (max -
el.scrollTop) to a non-negative value before including it in data; update the
same call site that uses emitRendererDiagnostic, visibleRangeData(),
props.hasScrollGesture(), props.scroll, and staging.isStaging() to use the
RAF-throttled emitter and the clamped distance metric.

In `@packages/app/src/pages/session/use-session-scroll-dock.ts`:
- Around line 172-179: The diagnostics hook input.onDockHeightChange is
currently invoked directly and can throw, breaking resize/scroll recovery; wrap
the invocation of input.onDockHeightChange (inside the dockHeight !==
previousDockHeight branch) in a try/catch so any exception is caught and does
not propagate, and log the error (e.g., via console.error or existing logger)
while keeping the conditional call (input.onDockHeightChange?.(...)) behavior
intact so diagnostics failures are fail-open.

In `@packages/desktop-electron/src/main/feedback.ts`:
- Around line 221-226: Wrap the await deps.rendererDiagnostics(context) call in
a timeout guard (e.g., Promise.race) so it cannot hang indefinitely; if the
timeout elapses, treat it as a handled error by calling
deps.onHandledError?.("renderer diagnostics slice timed out", timeoutError) and
set rendererDiagnostics = emptyRendererDiagnosticsSlice("write_failed", new
Date(generatedAt)) — mirror the fail-open behavior used for session export; use
a short configurable timeout constant (e.g., TIMEOUT_MS) and reference
deps.rendererDiagnostics, deps.onHandledError, emptyRendererDiagnosticsSlice,
and generatedAt when implementing.

In `@packages/desktop-electron/src/main/renderer-diagnostics.ts`:
- Around line 446-468: The record() function still writes events to disk even
when options.disabled is true; add an early check at the top of record (before
sanitizing/enqueueing) to honor options.disabled and immediately return { ok:
false, reason: "disabled" } (matching slice() behavior) so no further processing
(sanitizeRendererDiagnosticEvent, enqueueWrite, appendFile, flushRetention)
occurs when disabled.

---

Outside diff comments:
In `@packages/desktop-electron/src/main/problem-report.ts`:
- Around line 491-499: The type guard isTruncation currently omits checking
omittedRendererDiagnosticsBytes, so update isTruncation (the function checking
Payload["truncation"]) to also require
isFiniteNumber(value.omittedRendererDiagnosticsBytes); ensure the guard returns
false if that property is missing or non-numeric by adding it alongside the
other isFiniteNumber checks so parseProblemReportPayload can't produce a Payload
with an invalid truncation field.

---

Nitpick comments:
In `@packages/app/src/app.tsx`:
- Around line 50-51: The Window.api type is missing the exportDiagnosticsLog
method causing app-side typing drift; update the Window.api interface (the same
area that currently declares emitRendererDiagnostic) to also include
exportDiagnosticsLog with the same signature as the preload API—use the existing
RendererDiagnosticInput type if appropriate and ensure the method name and
parameter/return types match the exported preload surface so both
emitRendererDiagnostic and exportDiagnosticsLog are declared consistently.

In `@packages/desktop-electron/src/main/ipc-window-config.test.ts`:
- Around line 20-26: The test is brittle because it asserts string substrings
from src/main/ipc.ts instead of verifying the bootstrap wiring; update
packages/desktop-electron/src/main/ipc-window-config.test.ts to assert that the
bootstrap entry (src/main/index.ts) invokes the module-level registration
function(s) (e.g., registerRendererDiagnosticsIpc or the generic register*Ipc
exports) rather than checking for specific channel strings; modify the test to
import the bootstrap (index.ts) and spy/mock the exported register*Ipc
function(s) from the diagnostics module (or assert that index.ts imports and
calls registerRendererDiagnosticsIpc) so the test validates integration at the
bootstrap level and not file content.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/desktop-electron/src/main/renderer-diagnostics.ts`:
- Around line 266-279: parseEventLine currently returns any object-shaped data
from disk; update parseEventLine (the function returning
RendererDiagnosticEvent) to re-sanitize fields before returning: validate
event.name and level against the known allowlists (e.g., permitted event name
strings and allowed level values) and reject if not in those sets, and rebuild
the returned data object by copying only the allowed keys from the original
value.data (using your established allowlist for data fields) so no unexpected
properties are passed through to exportRendererDiagnosticsLog() or slice(); keep
all other existing shape checks and return undefined on any mismatch.
- Around line 510-517: The high-frequency throttling uses Date.now(), causing
divergence from the recorder's injected clock; change the timestamp source in
the block that computes `current` (where `key`, `current`, `previous`,
`lastHighFrequency`, and `highFrequencyIntervalMs` are used) to use the
recorder's injected time function (e.g., `options.now()` or the same `now` used
elsewhere) instead of `Date.now()` so rate limiting and retention follow the
same clock as the rest of the recorder.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/app/src/pages/session.tsx`:
- Around line 137-176: The emitRendererDiagnostic call inside the
createEffect/on callbacks can reject and cause unhandled promise rejections;
make these diagnostics "fail open" by ensuring the returned promise is
swallowed—attach a .catch(() => {}) (or equivalent try/catch around an awaited
call) to the emitRendererDiagnostic invocation in both places so any rejection
is suppressed; locate the calls to emitRendererDiagnostic inside the
createEffect/on callback(s) (symbols: createEffect, on, emitRendererDiagnostic,
timelineMessageMetrics) and add the catch handler to silently ignore errors.

In `@packages/app/src/pages/session/use-session-refresh-effects.ts`:
- Around line 26-63: syncSessionWithDiagnostics currently re-reads
input.timelineSessionID() inside the .then/.catch, causing end/failed events to
use a different session id if navigation occurs; capture the start-time IDs up
front (e.g., const startedVisibleId = input.timelineSessionID() and any other
session id used at start) and use those variables for
visible_session_id/timeline_session_id in the emitted *_end and *_failed events
instead of calling input.timelineSessionID() again; apply the same change to
syncTodoWithDiagnostics (and any similar helpers) so start and completion/failed
diagnostics consistently reference the same session ids.
- Around line 22-24: The emitRefresh helper currently calls
input.emitRendererDiagnostic?.(event) without handling rejected promises so
failures produce unhandled rejections; update emitRefresh to call
input.emitRendererDiagnostic?.(event) and explicitly handle the returned Promise
(e.g., chain .catch(...) or await inside a try/catch) to swallow or log errors
from the IPC/logger path; reference emitRefresh, input.emitRendererDiagnostic
and RendererDiagnosticInput when locating the call and ensure any caught error
is handled (logged via existing logger) or ignored so refreshes fail open.

In `@packages/desktop-electron/src/main/ipc.ts`:
- Around line 361-370: The call to deps.rendererDiagnosticsSlice(...) in the
export-session path can hang; wrap that await in the same timeout guard used by
feedback code so the slice fetch is bounded (e.g., Promise.race with a timeout
promise or reuse the existing timeout helper), and on timeout or rejection fall
back to rendererDiagnostics = emptyRendererDiagnosticsSlice("write_failed", new
Date()); adjust the surrounding try/catch so timeouts are handled the same way
feedback.ts does and ensure you reference the same
SESSION_EXPORT_RENDERER_DIAGNOSTICS_MAX_BYTES and windowID parameters when
invoking rendererDiagnosticsSlice.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/desktop-electron/src/main/index.ts`:
- Around line 585-587: The adapter currently ignores the IPC-provided window
context when calling reportProblem; update the exported adapter entry (the arrow
for reportProblem) to accept and forward the second argument so the call becomes
something like reportProblem(input, context) instead of only
reportProblem(input); ensure the symbol referenced in the diff (reportProblem)
and the IPC caller in packages/desktop-electron/src/main/ipc.ts
(deps.reportProblem(input, { windowID: win?.id })) are aligned and update any
TypeScript types/signature for reportProblem to accept the optional context
parameter so windowID is preserved through to the actual report handler.

In `@packages/desktop-electron/src/main/renderer-diagnostics.ts`:
- Around line 566-575: The code sets a module-scoped flag writeFailed in
record() on any write error and then causes slice() to always return
emptyRendererDiagnosticsSlice("write_failed", ...) even after the underlying log
becomes readable again; change this so writeFailed is only a transient failure
indicator: clear writeFailed when a subsequent readEventReport() or a successful
record() completes (e.g., set writeFailed = false after readEventReport()
succeeds or after successful writes), and ensure slice() only returns the
"write_failed" empty slice when the most recent I/O attempt actually failed
rather than relying on a permanent flag; update references in record(), slice(),
and the readEventReport() call to implement this behavior.

Verify each finding against the current code and only fix it if needed.

Nitpick comments:
In `@packages/desktop-electron/src/main/renderer-diagnostics.test.ts`:
- Around line 437-439: The fixture for the incident named
"incident.session_timeline_remount" uses non-allowlisted fields "mounts" and
"unmounts" which the sanitizer will drop; update the object in
renderer-diagnostics.test.ts (the fixture with name
"incident.session_timeline_remount") to use the sanitizer's allowlisted incident
field names instead—replace "mounts"/"unmounts" with the exact allowed keys from
the incident field allowlist used by the sanitizer (consult the sanitizer's
allowlist and use those key names) so the test validates payload retention
correctly.